En el algoritmo primero se realiza el ordenamiento del arreglo de días, y como se usa un merge sort, tiene complejidad $\mathcal{O}$(n*log(n)).

Luego se crea el array de tuplas, lo cual tiene complejidad $\mathcal{O}$(n), ya que es un loop que itera sobre el array entrada_ordenada de tamaño n.

Falta ver que como es la complejidad del loop principal del programa, la cual probaremos que es $\mathcal{O}$(n).
Para esto, lo que interesa estudiar son las guardas de los dos bucles while, ya que fuera de los ciclos, el resto son instrucciones con complejidad $\mathcal{O}$(1):

\begin{quote}
\begin{verbatim}
while startIndex < diasCount then      
   while endIndex < diasCount && 
      camionesPorDia[endIndex].día - camionesPorDia[startIndex].día < D) then
      ... // O(1)
      endIndex = endIndex + 1;
   endwhile
   ... // O(1)
   startIndex = startIndex + 1 // O(1)

   if endIndex >= diasCount then // O(1)
      startIndex = diasCount // O(1)
   endif
endwhile
\end{verbatim}
\end{quote}

Dado que startIndex se inicializa en 0 y que en cada iteración del bucle principal, aumenta en 1, entonces se deduce(dado que la guarda es "startIndex < diasCount") que el bucle principal se ejecuta a lo sumo diasCount veces.
Si analizamos el bucle interno, dado que endIndex se inicializa en 0, y cada vez que se ejecuta una iteración de dicho bucle, endIndex se incrementa en 1, luego el bucle interno se ejecuta a lo sumo diasCount veces dada la sentencia "endIndex < diasCount" en la guarda y dado que no se modifica endIndex en ninguna otra parte del algoritmo.
Como el bucle interno se ejecuta a lo sumo diasCount veces sin importar la cantidad de iteraciónes del bucle principal, ambos bucles se ejecutan a lo sumo una vez, diasCount veces. Luego la complejidad del algoritmo es $\mathcal{O}$(diasCount + diasCount) = $\mathcal{O}$(2*diasCount) = $\mathcal{O}$(diasCount).
Como diasCount es la cantidad de días distintos en que llegan camiones y n la cantidad de camiones que llegan y dado que puede llegar más de un camión en un día entonces, diasCount <= n para todo valor de diasCount y n. Luego $\mathcal{O}$(diasCount) = $\mathcal{O}$(n)

Luego la complejidad total del algoritmo es:

$\mathcal{O}$(n*log(n)+n+n) = $\mathcal{O}$(n*log(n))